Python Logging Çerçevesi: Handler Yapılandırması ve Özel Biçimlendiriciler

Python'un logging çerçevesi, uygulama davranışını yönetmek ve izlemek için güçlü bir araçtır. Etkili kayıt tutma, hata ayıklama, sorun giderme ve yazılımınızın performansı hakkında içgörüler elde etmek için çok önemlidir. Bu kapsamlı kılavuz, Python logging çerçevesinin iki temel yönünü derinlemesine ele almaktadır: Handler yapılandırması ve Özel Biçimlendiriciler. Dünya'nın neresinde olursanız olun, Python projelerinizde sağlam ve verimli kayıt tutma sistemleri uygulamanıza yardımcı olmak için bunların işlevlerini, en iyi uygulamalarını ve pratik örneklerini keşfedeceğiz.

Python Logging Temellerini Anlamak

Handler'lara ve formatlayıcılara geçmeden önce, Python logging çerçevesinin temel bileşenleri hakkında sağlam bir anlayış oluşturalım:

• Logger'lar (Kaydediciler): Logger'lar, uygulamanızın log mesajları yazması için birincil arayüzdür. Hiyerarşiktirler, yani bir logger'ın alt logger'ları olabilir ve yapılandırmayı ebeveynlerinden miras alabilirler. Onları log mesajlarınızın kapı bekçileri olarak düşünebilirsiniz.
• Log Seviyeleri: Log seviyeleri (DEBUG, INFO, WARNING, ERROR, CRITICAL) log mesajlarının önem derecesini kategorize eder. Hangi mesajların işleneceğini filtrelemek için bu seviyeleri kullanırsınız. Örneğin, bir üretim ortamında, ayrıntıyı azaltmak için yalnızca WARNING, ERROR ve CRITICAL mesajlarını kaydedebilirsiniz.
• Handler'lar (İşleyiciler): Handler'lar, log mesajlarının nereye gönderileceğini belirler. Bu, konsol (stdout), bir dosya, bir ağ soketi veya hatta bir veritabanı olabilir. Handler'lar, log seviyesine göre filtreleme yapacak ve formatlayıcıları uygulayacak şekilde yapılandırılabilir.
• Formatlayıcılar (Biçimlendiriciler): Formatlayıcılar, log mesajlarınızın yapısını ve içeriğini tanımlar. Hangi bilgilerin dahil edileceğini (zaman damgası, logger adı, log seviyesi, mesaj içeriği vb.) ve nasıl sunulacağını kontrol ederler. Formatlayıcılar, log mesajı yazılmadan önce handler tarafından uygulanır.

Bu bileşenler, esnek ve yapılandırılabilir bir kayıt tutma sistemi sağlamak için birlikte çalışır. Bir log mesajı logger'da başlar, bir handler'dan geçer ve hedefine gönderilmeden önce bir formatlayıcı kullanılarak biçimlendirilir. Bu yapı, logların nasıl oluşturulduğu, işlendiği ve saklandığı üzerinde ayrıntılı kontrol sağlar.

Handler Yapılandırması: Loglarınızı Etkili Bir Şekilde Yönlendirme

Handler'lar, log mesajlarınızı nihai hedeflerine yönlendirmekten sorumlu olan logging çerçevesinin iş gücüdür. Etkili kayıt tutma için doğru handler yapılandırması hayati önem taşır. İşte dikkate alınması gereken temel noktalar:

Yaygın Handler Türleri:

• StreamHandler: Log mesajlarını bir akışa, genellikle stdout veya stderr'e gönderir. Geliştirme sırasında konsol kaydı için idealdir.
• FileHandler: Log mesajlarını bir dosyaya yazar. Özellikle üretimde, uygulama olaylarının kalıcı olarak kaydedilmesi için gereklidir. Bu, dağıtımdan sonra ortaya çıkan sorunları ayıklamak için çok önemlidir.
• RotatingFileHandler: Belirli bir boyuta ulaştıklarında veya belirli zaman aralıklarında log dosyalarını otomatik olarak döndüren bir FileHandler alt sınıfıdır. Tek bir log dosyasının süresiz olarak büyümesini önleyerek performansı ve yönetilebilirliği artırır.
• TimedRotatingFileHandler: RotatingFileHandler'a benzer ancak zamana göre (günlük, haftalık vb.) döndürme yapar. Logları tarihe göre düzenlemek için kullanışlıdır.
• SocketHandler: Log mesajlarını bir ağ soketi üzerinden gönderir. Birden fazla uygulamadan gelen logları merkezileştirmenize olanak tanıyan uzaktan kayıt tutmayı sağlar.
• SMTPHandler: Log mesajlarını e-posta yoluyla gönderir. Kritik hatalar veya uyarılar hakkında bilgilendirme için kullanışlıdır.

Handler'ları Python'da Yapılandırma:

Handler'ları yapılandırmanın iki temel yolu vardır:

1. Programatik Yapılandırma: Bu, Python kodunuzda doğrudan handler örnekleri oluşturmayı ve bunları logger'lara eklemeyi içerir. Bu yaklaşım, uygulama ihtiyaçlarına göre kayıt tutma davranışını dinamik olarak ayarlamanıza olanak tanıyarak en fazla esnekliği ve kontrolü sağlar.
2. Yapılandırma Dosyaları (örneğin, YAML, JSON, INI): Yapılandırma dosyalarını kullanmak, kayıt tutma yapılandırmasını uygulama kodunuzdan ayırmanıza olanak tanır, bu da kod değişikliği yapmadan kayıt tutma ayarlarını yönetmeyi ve değiştirmeyi kolaylaştırır. Bu, özellikle dağıtım ortamları için yararlıdır.

Programatik Handler Örneği:

Programatik yapılandırmayı, konsola ve bir dosyaya yazan basit bir örnekle gösterelim. Bu örnek temel yapıyı göstermektedir. Projeniz için dosya yollarını ve log seviyelerini gerektiği gibi ayarlamayı unutmayın.

            import logging

# Create a logger
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG) # Set the root logger level

# Create a handler to print to the console (stdout)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO) # Set level for this handler

# Create a handler to write to a file
file_handler = logging.FileHandler('my_app.log')
file_handler.setLevel(logging.DEBUG) # Log everything to the file

# Create formatters (explained later)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add the handlers to the logger
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Example log messages
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

            

              
                Copy
              
            
          

Örnekteki önemli noktalar:

• logging.getLogger() kullanarak bir logger örneği oluşturuyoruz. Argüman genellikle modül adı veya uygulamaya özgü bir addır.
• Kök logger (bu durumda 'my_app') için log seviyesini ayarlıyoruz. Bu, logger tarafından işlenecek mesajların *minimum* önem seviyesini belirler.
• Biri konsol (StreamHandler) ve diğeri dosya (FileHandler) için olmak üzere iki handler oluşturuyoruz.
• *Her* handler için seviyeyi ayarlıyoruz. Bu, filtrelemeye olanak tanır. Örneğin, konsol handler'ı yalnızca INFO ve üzeri mesajları gösterirken, dosya handler'ı tüm mesajları (DEBUG ve üzeri) kaydeder.
• Her handler'a bir formatlayıcı ekliyoruz (aşağıda ayrıntılı olarak açıklanmıştır).
• logger.addHandler() kullanarak handler'ları logger'a ekliyoruz.
• Farklı seviyelerde log mesajları oluşturmak için logger'ı kullanıyoruz.

Yapılandırma Dosyası Örneği (YAML):

Bir yapılandırma dosyası (örneğin, YAML) kullanmak, kayıt tutma ayarlarınızı harici olarak tanımlamanıza olanak tanır, bu da kodu değiştirmeden kayıt tutma davranışını değiştirmeyi kolaylaştırır. İşte `logging.config.dictConfig()` fonksiyonunu kullanan bir örnek:

            import logging
import logging.config
import yaml

# Load the configuration from a YAML file
with open('logging_config.yaml', 'r') as f:
    config = yaml.safe_load(f)

# Configure logging
logging.config.dictConfig(config)

# Get a logger (the name should match the one defined in the config file)
logger = logging.getLogger('my_app')

# Example log messages
logger.debug('This is a debug message from the config')
logger.info('This is an info message from the config')

            

              
                Copy
              
            
          

Ve işte örnek bir logging_config.yaml dosyası:

            version: 1
formatters:
  simple:
    format: '%(levelname)s - %(message)s'
  detailed:
    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
handlers:
  console:
    class: logging.StreamHandler
    level: INFO
    formatter: simple
    stream: ext://sys.stdout
  file:
    class: logging.FileHandler
    level: DEBUG
    formatter: detailed
    filename: my_app_config.log
loggers:
  my_app:
    level: DEBUG
    handlers: [console, file]
    propagate: no
root:
  level: WARNING # Defaults, if not set in logger.
            

              
                Copy
              
            
          

YAML yapılandırmasının açıklaması:

• version: 1: Yapılandırma dosyası sürümünü belirtir.
• formatters: Mevcut formatlayıcıları tanımlar.
• handlers: Handler'ları tanımlar. Her handler, sınıfını, seviyesini, formatlayıcısını ve hedefini (örneğin, konsol, dosya) belirtir.
• loggers: Logger'ları tanımlar. Burada, 'my_app' logger'ını hem 'console' hem de 'file' handler'larını kullanacak şekilde yapılandırıyoruz. Ayrıca log seviyesini de ayarlıyoruz.
• root: Logger'larda ayarlanmamışsa varsayılan bir yapılandırma.

Yapılandırma dosyalarının temel avantajları:

• Sorumlulukların Ayrılması: Kayıt tutma yapılandırmanızı temel uygulama mantığınızdan ayrı tutar.
• Kolay Değişiklik: Kayıt tutma davranışını (örneğin, log seviyeleri, çıktı hedefleri) değiştirmek, kodunuzu değil, yalnızca yapılandırma dosyasını değiştirmeyi gerektirir.
• Dağıtım Esnekliği: Kayıt tutmayı farklı ortamlara (geliştirme, test, üretim) kolayca uyarlamanıza olanak tanır.

Özel Formatlayıcılar: Log Mesajlarınızı Özelleştirme

Formatlayıcılar, log mesajlarınızın yapısını ve içeriğini kontrol eder. Loglarınızda görüntülenen bilgileri özelleştirmenize olanak tanıyarak uygulama davranışını anlamayı ve analiz etmeyi kolaylaştırır. Formatlayıcılar, hangi ayrıntıların dahil edileceğini (zaman damgası, logger adı, log seviyesi, mesaj vb.) ve nasıl sunulacaklarını belirler.

Formatlayıcı Bileşenlerini Anlamak:

Formatlayıcılar, log kayıtlarının nasıl biçimlendirileceğini tanımlayan bir format dizesi kullanır. İşte yaygın olarak kullanılan bazı format belirleyicileri:

• %(asctime)s: Log kaydının oluşturulduğu zaman (ör. '2024-01-01 12:00:00,000').
• %(name)s: Logger'ın adı (ör. 'my_app.module1').
• %(levelname)s: Log seviyesi (ör. 'INFO', 'WARNING', 'ERROR').
• %(message)s: Log mesajı.
• %(filename)s: Log mesajının kaynaklandığı dosya adı.
• %(lineno)d: Log mesajının kaynaklandığı satır numarası.
• %(funcName)s: Log mesajının kaynaklandığı fonksiyonun adı.
• %(pathname)s: Kaynak dosyanın tam yolu.
• %(threadName)s: Thread'in adı.
• %(process)d: İşlem (process) ID'si.

Özel Formatlayıcılar Oluşturma:

Uygulamanızın ihtiyaçlarına göre özel bilgiler eklemek için özel formatlayıcılar oluşturabilirsiniz. Bu, `logging.Formatter` sınıfından bir alt sınıf oluşturarak ve `format()` metodunu geçersiz kılarak (override) elde edilir. `format()` metodu içinde, log kaydının niteliklerine erişebilir ve mesajı gerektiği gibi biçimlendirebilirsiniz.

            import logging

class CustomFormatter(logging.Formatter):
    def format(self, record):
        # Get the original formatted message
        log_fmt = super().format(record)

        # Add custom information
        custom_info = f' - User: {record.user_id if hasattr(record, "user_id") else "Guest"}' # Example customization
        return log_fmt + custom_info

# Example Usage (Illustrative:  Requires setting up a handler and attaching the custom formatter)
if __name__ == '__main__':
    logger = logging.getLogger('custom_logger')
    logger.setLevel(logging.INFO)

    # Create a console handler
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)

    # Set the custom formatter on the handler
    formatter = CustomFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    ch.setFormatter(formatter)

    # Add the handler to the logger
    logger.addHandler(ch)

    # Create a log record with custom attribute (simulated for demonstration)
    class LogRecordWithUser(logging.LogRecord):
        def __init__(self, name, level, pathname, lineno, msg, args, exc_info, func, sinfo, user_id=None):
            super().__init__(name, level, pathname, lineno, msg, args, exc_info, func, sinfo)
            self.user_id = user_id
    
    #Example message with a user id
    record = LogRecordWithUser('custom_logger', logging.INFO, 'example.py', 10, 'User logged in', (), None, 'main', None, user_id='12345')
    logger.handle(record)

    # Example message without a user id
    logger.info('Guest user accessed the page.')

            

              
                Copy
              
            
          

Özel formatlayıcı örneğinin açıklaması:

• `logging.Formatter` sınıfından miras alan `CustomFormatter` adlı bir sınıf oluşturuyoruz.
• `format()` metodu geçersiz kılınmıştır. Özel biçimlendirme mantığı burada yer alır.
• Önce `super().format(record)` kullanarak standart biçimlendirilmiş mesajı alıyoruz.
• Özel bilgiler ekliyoruz. Bu örnekte, log kaydının bir niteliği olarak varsa kullanıcı bilgisini (kullanıcı ID) ekliyoruz. Eğer yoksa (misafir kullanıcı gibi), "Guest" gösterir. `hasattr()` kontrolünün ve user_id niteliğinin koşullu olarak dahil edilmesinin, niteliğin tanımlanmadığı durumlarda hatalardan kaçınmanıza nasıl yardımcı olduğuna dikkat edin.
• Örnek, o anda oturum açmış olan kullanıcı hakkındaki bilgileri içerecek şekilde bir log mesajının nasıl işleneceğini göstermektedir.

Farklı Kullanım Durumları için Log Mesajlarını Biçimlendirme:

İhtiyaçlarınız için en uygun biçimlendirmeyi seçmenize yardımcı olacak farklı formatlayıcı stillerine bazı örnekler aşağıda verilmiştir.

1. Temel Biçimlendirme (geliştirme için):

               '%(asctime)s - %(levelname)s - %(message)s'
               
   
                 
                   Copy
                 
               
             

   Bu format, basit bir zaman damgası, log seviyesi ve mesaj sağlar. Hızlı hata ayıklama için iyidir.
2. Ayrıntılı Biçimlendirme (üretim için, dosya/satır numarası ile):

               '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s'
               
   
                 
                   Copy
                 
               
             

   Bu format, logger adını, dosya adını, satır numarasını ve log mesajını içerir, bu da logların kaynağını izlemeyi kolaylaştırır.
3. JSON Biçimlendirme (makine ayrıştırması için):

   Otomatik log analizi için (örneğin, bir log toplama sistemi ile), JSON biçimlendirmesi oldukça etkilidir. Bu, yapılandırılmış verilere olanak tanır, bu da daha kolay ayrıştırma ve analiz sağlar. Özel bir formatlayıcı sınıfı oluşturmanız ve log kaydını JSON olarak kodlamak için `json.dumps()` kullanmanız gerekecektir.

               import json
   import logging
   
   class JsonFormatter(logging.Formatter):
       def format(self, record):
           log_record = {
               'timestamp': self.formatTime(record, self.datefmt),
               'name': record.name,
               'levelname': record.levelname,
               'message': record.getMessage(),
               'filename': record.filename,
               'lineno': record.lineno,
               'funcName': record.funcName
           }
           return json.dumps(log_record)
   
               
   
                 
                   Copy
                 
               
             

   Bu formatlayıcı, ilgili log verilerini içeren bir JSON yapısı oluşturur. Dosya, satır numarası ve fonksiyon adı, kaynak kod içinde kolayca geri izleme yapılmasına olanak tanır. Bu biçimlendirilmiş çıktı daha sonra log analiz araçları tarafından kolayca ayrıştırılır.

4. Özel Uygulamalar için Biçimlendirme:

   Formatlayıcılarınızı bağlama özgü bilgileri içerecek şekilde uyarlayın. Uygulamanız kullanıcı kimlik doğrulaması yapıyorsa, kullanıcı ID'lerini ekleyin. Finansal işlemleri işliyorsanız, işlem ID'lerini ekleyin. Kayıt çıktınızı, iş bağlamınız için neyin yararlı olduğuna ve en çok karşılaşacağınız sorun türlerine göre uyarlayın.

Python Logging için En İyi Uygulamalar

En iyi uygulamaları takip etmek, kayıt tutmanızın etkili, sürdürülebilir ve değerli olmasını sağlar. İşte bazı temel öneriler:

• Log Seviyesi Granülerliği: Uygun log seviyelerini tutarlı bir şekilde kullanın.
  • DEBUG: Ayrıntılı bilgi, genellikle hata ayıklama için.
  • INFO: Uygulama çalışması hakkında genel bilgi.
  • WARNING: Potansiyel sorunlar veya beklenmedik olaylar.
  • ERROR: Bir fonksiyonun veya işlevselliğin çalışmasını engelleyen hatalar.
  • CRITICAL: Uygulamanın çökmesine veya kararsız hale gelmesine neden olabilecek ciddi hatalar.

  Kaydedilen olayın ciddiyetini doğru bir şekilde yansıtan seviyeyi seçin.

• Bağlamsal Bilgi: Log mesajlarınıza ilgili bağlamı dahil edin. Kullanıcı ID'leri, istek ID'leri, işlem ID'leri veya bir sorunu kaynağına kadar izlemenize yardımcı olabilecek diğer bilgileri ekleyin.
• Hata Yönetimi: İstisnaları her zaman logger.exception() kullanarak veya istisna bilgilerini log mesajına dahil ederek kaydedin. Bu, hata ayıklama için paha biçilmez olan yığın izlerini (stack trace) sağlar.
• Merkezi Kayıt Tutma (dağıtık sistemler için): Merkezi bir kayıt tutma sistemi (örneğin, Elasticsearch, Fluentd, Splunk veya ELK yığını -- Elasticsearch, Logstash ve Kibana) kullanmayı düşünün. Bu, birden fazla uygulama ve sunucudan logları toplamanıza olanak tanır, bu da sistemlerinizi aramayı, analiz etmeyi ve izlemeyi kolaylaştırır. Bulut bilişim dünyasında, çeşitli hizmetler yönetilen kayıt tutma sunar, ör. AWS CloudWatch, Azure Monitor ve Google Cloud Logging.
• Döndürme ve Saklama: Log dosyalarının çok büyümesini önlemek için log döndürmeyi (`RotatingFileHandler` veya `TimedRotatingFileHandler` kullanarak) uygulayın. Belirli bir süreden sonra logları otomatik olarak silmek veya arşivlemek için bir saklama politikası oluşturun. Bu, uyumluluk, güvenlik ve depolama yönetimi için önemlidir.
• Hassas Bilgilerden Kaçının: Şifreler, API anahtarları veya kişisel veriler gibi hassas bilgileri asla kaydetmeyin. GDPR veya CCPA gibi gizlilik düzenlemelerine uyumu sağlayın. Uygulama hassas verileri işliyorsa dikkatli filtreleme uygulayın.
• Yapılandırma Odaklı Kayıt Tutma: Kayıt tutma ayarlarınızı yönetmek için yapılandırma dosyalarını (YAML, JSON veya INI) kullanın. Bu, kodunuzu değiştirmeden log seviyelerini, handler'ları ve formatlayıcıları değiştirmeyi kolaylaştırır, bu da kayıt tutmayı farklı ortamlar için özelleştirmenize olanak tanır.
• Performans Değerlendirmeleri: Özellikle kodunuzun performansa duyarlı bölümlerinde aşırı kayıt tutmaktan kaçının. Kayıt tutma ek yük getirebilir, bu nedenle uygulama performansı üzerindeki etkisine dikkat edin. Gerektiğinde uygun log seviyelerini kullanın ve mesajları filtreleyin.
• Kayıt Tutmayı Test Etme: Kayıt tutma yapılandırmanızı ve log mesajlarınızın doğru bir şekilde oluşturulduğunu doğrulamak için birim testleri yazın. Doğru çalışmayı sağlamak için farklı log seviyelerini ve senaryoları test etmeyi düşünün.
• Belgelendirme: Log seviyeleri, handler'lar ve formatlayıcılar dahil olmak üzere kayıt tutma yapılandırmanızı belgeleyin. Bu, diğer geliştiricilerin kayıt tutma kurulumunuzu anlamasına yardımcı olur ve kodunuzu sürdürmeyi ve sorun gidermeyi kolaylaştırır.
• Kullanıcı ID ve İstek ID Korelasyonu: Web uygulamaları veya birden fazla isteği işleyen herhangi bir hizmet için, benzersiz bir istek ID'si oluşturun ve bunu belirli bir istekle ilgili her log mesajına dahil edin. Benzer şekilde, uygun olduğunda bir kullanıcı ID'si ekleyin. Bu, istekleri birden fazla hizmet arasında izlemeye ve belirli kullanıcılarla ilgili sorunları ayıklamaya yardımcı olur.

Pratik Örnekler ve Kullanım Senaryoları

Etkili kayıt tutmanın çok önemli olduğu bazı gerçek dünya senaryolarını inceleyelim:

1. Web Uygulaması İzleme:

Bir web uygulamasında, kullanıcı isteklerini izlemek, hataları takip etmek ve performans darboğazlarını belirlemek için kayıt tutmayı kullanabilirsiniz.

            import logging
from flask import Flask, request

app = Flask(__name__)

# Configure logging (using a config file, or a programmatic example here)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

@app.route('/')
def index():
    # Generate a request ID (for example)
    request_id = request.headers.get('X-Request-Id')
    if not request_id:
        request_id = 'unknown'
    
    logger.info(f'Request received, Request ID: {request_id}')
    try:
        # Simulate an error condition
        if request.args.get('error'):
            raise ValueError('Simulated error')
        return 'Hello, World!'
    except Exception as e:
        logger.error(f'Error processing request {request_id}: {str(e)}')
        return 'Internal Server Error', 500

if __name__ == '__main__':
    app.run(debug=True)  # Be very careful using debug=True in production.
            

              
                Copy
              
            
          

Bu örnekte:

• Bireysel istekleri izlemek için bir istek ID'si oluştururuz (veya alırız).
• İsteği istek ID'si ile kaydederiz.
• İstisna ve istek ID'si dahil olmak üzere tüm hataları kaydederiz.

2. Arka Plan Görevleri / Zamanlanmış İşler:

Kayıt tutma, zamanlanmış işler veya veri işleme hatları gibi arka plan görevlerini izlemek için kritiktir.

            import logging
import time
from datetime import datetime

# Configure logging (again, using config file is generally better)
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def my_scheduled_task():
    start_time = datetime.now()
    logger.info(f'Starting scheduled task at {start_time}')
    try:
        # Simulate some work
        time.sleep(2)  # Simulate work
        # Simulate a potential error
        if datetime.now().minute % 5 == 0:
            raise ValueError('Simulated error in task')
        logger.info('Task completed successfully')
    except Exception as e:
        logger.error(f'Task failed: {str(e)}')
    finally:
      end_time = datetime.now()
      logger.info(f'Task finished at {end_time}.  Duration: {end_time - start_time}')

if __name__ == '__main__':
    my_scheduled_task()
            

              
                Copy
              
            
          

Bu, bir görevin yürütülmesinden önce, sırasında ve sonrasında kayıt tutmayı gösterir, başarıyı ve başarısızlığı gösterir. Bu, zamanlama sorunlarını teşhis etmeyi kolaylaştıracaktır.

3. Veri İşleme Hattı:

Bir veri işleme hattında, kayıt tutma veri dönüşümlerini izlemenize, hataları tespit etmenize ve genel hat sağlığını izlemenize yardımcı olur.

            import logging
import pandas as pd

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def load_data(file_path):
    try:
        df = pd.read_csv(file_path) # Replace with your file type
        logger.info(f'Data loaded from {file_path}, shape: {df.shape}')
        return df
    except FileNotFoundError:
        logger.error(f'File not found: {file_path}')
        return None
    except Exception as e:
        logger.error(f'Error loading data: {str(e)}')
        return None

def transform_data(df):
    if df is None:
        return None
    try:
        # Apply some transformation
        df['processed_column'] = df['some_column'] * 2  # Example
        logger.info('Data transformation completed.')
        return df
    except Exception as e:
        logger.error(f'Error transforming data: {str(e)}')
        return None

def save_data(df, output_file):
    if df is None:
        return
    try:
        df.to_csv(output_file, index=False)  # Modify for different output format
        logger.info(f'Data saved to {output_file}')
    except Exception as e:
        logger.error(f'Error saving data: {str(e)}')

# Example Usage (replace with your actual file paths and data)
if __name__ == '__main__':
    input_file = 'input.csv'
    output_file = 'output.csv'

    data = load_data(input_file)
    transformed_data = transform_data(data)
    save_data(transformed_data, output_file)
            

              
                Copy
              
            
          

Bu hat örneği, veri yükleme, dönüştürme ve kaydetme işlemlerini kaydeder. Kayıt ifadeleri, süreci izlemenize ve bir şeyler ters giderse sorunları kolayca teşhis etmenize olanak tanır.

İleri Düzey Logging Teknikleri

Temellerin ötesinde, kayıt tutma yeteneklerinizi en üst düzeye çıkarmak için bu ileri düzey teknikleri göz önünde bulundurun:

• Logging ContextVars: `contextvars` modülü (Python 3.7+ sürümünde mevcuttur), bağlama özgü verileri (örneğin, istek ID'leri, kullanıcı ID'leri) saklamanıza ve bunları otomatik olarak log mesajlarınıza dahil etmenize olanak tanır. Bu, her kayıt çağrısına manuel olarak geçirmek zorunda kalmadan loglarınıza bağlamsal bilgi ekleme sürecini basitleştirir. Bu, standart kod miktarını azaltır ve kodun sürdürülebilirliğini artırır.
• Logging Filtreleri: Hangi log mesajlarının handler'lar tarafından işleneceğini daha da hassaslaştırmak için filtreler kullanın. Filtreler, örneğin, kaynak modüle veya belirli bir değişkenin değerine göre mesajları koşullu olarak kaydetmek için kullanılabilir.
• Logging Kütüphaneleri Entegrasyonu: Kayıt tutmanızı projenizde kullanılan diğer kütüphaneler ve çerçevelerle entegre edin. Örneğin, Flask veya Django gibi bir web çerçevesi kullanıyorsanız, HTTP istekleri ve yanıtları hakkında bilgileri otomatik olarak kaydetmek için kayıt tutmayı yapılandırabilirsiniz.
• Log Toplama ve Analiz (ELK Stack, vb.): Bir log toplama sistemi uygulayın. ELK yığınını (Elasticsearch, Logstash, Kibana) veya diğer bulut tabanlı çözümleri kullanmayı düşünün. Bu sistemler, çeşitli kaynaklardan logları toplamanıza, merkezileştirmenize ve analiz etmenize olanak tanıyarak güçlü arama, filtreleme ve görselleştirme yetenekleri sunar. Bu, eğilimleri belirleme, anormallikleri tespit etme ve sorunları giderme yeteneğinizi artırır.
• İzleme ve Dağıtık İzleme: Mikroservisler veya dağıtık uygulamalar için, istekleri birden fazla hizmetten geçerken izlemek için izleme uygulayın. Jaeger, Zipkin ve OpenTelemetry gibi kütüphaneler izlemede yardımcı olur. Bu, farklı hizmetler arasında log mesajlarını ilişkilendirmenize olanak tanır, uygulamanızın uçtan uca davranışı hakkında içgörüler sağlar ve karmaşık dağıtık sistemlerde performans darboğazlarını belirler.

Sonuç: Başarı için Logging

Etkili kayıt tutma, yazılım geliştirmenin temel bir yönüdür. Python'un logging çerçevesi, uygulamalarınızda kapsamlı kayıt tutma uygulamanız için gereken araçları sağlar. Handler yapılandırmasını, özel formatlayıcıları ve en iyi uygulamaları anlayarak, sağlam ve verimli kayıt tutma çözümleri oluşturabilir ve şunları yapabilirsiniz:

• Etkili bir şekilde hata ayıklama: Sorunların temel nedenini daha hızlı bir şekilde belirleyin.
• Uygulama sağlığını izleme: Potansiyel sorunları proaktif olarak belirleyin.
• Uygulama performansını iyileştirme: Kayıt tutma içgörülerine dayanarak kodunuzu optimize edin.
• Değerli içgörüler elde etme: Uygulamanızın nasıl kullanıldığını anlayın.
• Yasal gereklilikleri karşılama: Kayıt tutma ve denetim standartlarına uyun.

İster yolculuğuna yeni başlayan bir junior geliştirici olun, ister büyük ölçekli dağıtık sistemler kuran deneyimli bir profesyonel, Python'un logging çerçevesi hakkında sağlam bir anlayış paha biçilmezdir. Bu kavramları uygulayın, örnekleri kendi özel ihtiyaçlarınıza göre uyarlayın ve küresel ortam için daha güvenilir ve sürdürülebilir yazılımlar oluşturmak için kayıt tutmanın gücünü benimseyin. Tutarlı kayıt tutma, üretkenliğinizi artıracak ve uygulamalarınızın hak ettikleri başarıya ulaşmasını sağlamak için gereken kritik içgörüleri sağlayacaktır.